
#include "stdafx.h"
#include "Base64Coder.h"

// Digits...
static char Base64Digits[]          = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static char AlternateBase64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-"; //modified Base64 for filename


BOOL Base64Coder::m_Init    = FALSE;
char Base64Coder::m_DecodeTable[256];
bool AlternateDigits        = false;

#ifndef PAGESIZE
#define PAGESIZE          4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a)      (((a/4096)+1)*4096)
#endif

//{{{
Base64Coder::Base64Coder(bool useAlternateMapping)
  : m_pDBuffer(NULL), m_pEBuffer(NULL), m_nDBufLen(0), m_nEBufLen(0), m_nEDataLen(0),
  m_useAlternateMapping(useAlternateMapping), m_nDecodedLength(-1)
{
  if (m_Init)
  {
    if (AlternateDigits != m_useAlternateMapping)
    {
      m_Init    = FALSE;
    }
  }
}
//}}}
//{{{
Base64Coder::~Base64Coder() {
  if(m_pDBuffer != NULL)
    delete [] m_pDBuffer;

  if(m_pEBuffer != NULL)
    delete [] m_pEBuffer;
  }
//}}}

//{{{
unsigned char* Base64Coder::DecodedMessage() const {
  return m_pDBuffer;
  }
//}}}
//{{{
unsigned int Base64Coder::DecodedLength() const {
  return m_nDecodedLength;
  }
//}}}
//{{{
unsigned char* Base64Coder::EncodedMessage() const {
  return m_pEBuffer;
  }
//}}}
//{{{
unsigned int Base64Coder::EncodedLength() const {
  return m_nEDataLen;
  }
//}}}

//{{{
void Base64Coder::AllocEncode (DWORD nSize) {
  if(m_nEBufLen < nSize) {
    if(m_pEBuffer != NULL)
      delete [] m_pEBuffer;

    m_nEBufLen = ROUNDTOPAGE(nSize);
    m_pEBuffer = new BYTE[m_nEBufLen];
    }

  ::ZeroMemory(m_pEBuffer, m_nEBufLen);
  m_nEDataLen = 0;
  }
//}}}
//{{{
void Base64Coder::AllocDecode (DWORD nSize) {
  if(m_nDBufLen < nSize) {
    if(m_pDBuffer != NULL)
      delete [] m_pDBuffer;

    m_nDBufLen = ROUNDTOPAGE(nSize);
    m_pDBuffer = new BYTE[m_nDBufLen];
    }

  ::ZeroMemory(m_pDBuffer, m_nDBufLen);
  m_nDDataLen = 0;
  }
//}}}

//{{{
void Base64Coder::SetEncodeBuffer (const PBYTE pBuffer, DWORD nBufLen) {
  DWORD i = 0;

  AllocEncode(nBufLen);
  while(i < nBufLen) {
    if(!_IsBadMimeChar(pBuffer[i])) {
      m_pEBuffer[m_nEDataLen] = pBuffer[i];
      ++m_nEDataLen;
      }

    ++i;
    }
  }
//}}}
//{{{
void Base64Coder::SetDecodeBuffer (const PBYTE pBuffer, DWORD nBufLen) {
  AllocDecode(nBufLen);
  ::CopyMemory(m_pDBuffer, pBuffer, nBufLen);
  m_nDDataLen = nBufLen;
  }
//}}}

//{{{
void Base64Coder::Encode (const PBYTE pBuffer, DWORD nBufLen) {
  SetDecodeBuffer(pBuffer, nBufLen);
  AllocEncode(nBufLen * 2);

  TempBucket      Raw;
  DWORD         nIndex  = 0;

  while((nIndex + 3) <= nBufLen) {
    Raw.Clear();
    ::CopyMemory(&Raw, m_pDBuffer + nIndex, 3);
    Raw.nSize = 3;
    _EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
    nIndex    += 3;
    m_nEDataLen += 4;
    }

  if(nBufLen > nIndex) {
    Raw.Clear();
    Raw.nSize = (BYTE) (nBufLen - nIndex);
    ::CopyMemory(&Raw, m_pDBuffer + nIndex, nBufLen - nIndex);
    _EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
    m_nEDataLen += 4;
    }
  }
//}}}
//{{{
void Base64Coder::Encode (const char* szMessage) {
  if(szMessage != NULL)
    Base64Coder::Encode((const PBYTE)szMessage, strlen(szMessage));
  }
//}}}

//{{{
void Base64Coder::Decode (const PBYTE pBuffer, DWORD dwBufLen) {
  if(!Base64Coder::m_Init)
    _Init();

  m_nDecodedLength = -1;

  SetEncodeBuffer(pBuffer, dwBufLen);

  AllocDecode(dwBufLen);

  TempBucket      Raw;

  DWORD   nIndex = 0;

  while((nIndex + 4) <= m_nEDataLen) {
    Raw.Clear();
    Raw.nData[0] = Base64Coder::m_DecodeTable[m_pEBuffer[nIndex]];
    Raw.nData[1] = Base64Coder::m_DecodeTable[m_pEBuffer[nIndex + 1]];
    Raw.nData[2] = Base64Coder::m_DecodeTable[m_pEBuffer[nIndex + 2]];
    Raw.nData[3] = Base64Coder::m_DecodeTable[m_pEBuffer[nIndex + 3]];

    if(Raw.nData[2] == 255)
      Raw.nData[2] = 0;
    if(Raw.nData[3] == 255)
      Raw.nData[3] = 0;

    Raw.nSize = 4;
    ULONG decoded = _DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
    nIndex += 4;
    m_nDDataLen += 3;
    }

   // If nIndex < m_nEDataLen, then we got a decode message without padding.
   // We may want to throw some kind of warning here, but we are still required
   // to handle the decoding as if it was properly padded.
  if(nIndex < m_nEDataLen) {
    Raw.Clear();
    for(DWORD i = nIndex; i < m_nEDataLen; ++i) {
      Raw.nData[i - nIndex] = Base64Coder::m_DecodeTable[m_pEBuffer[i]];
      ++(Raw.nSize);
      if(Raw.nData[i - nIndex] == 255)
        Raw.nData[i - nIndex] = 0;
      }

    _DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
    m_nDDataLen += (m_nEDataLen - nIndex);
    }

    m_nDecodedLength = m_nDDataLen;
    //reduce depending on padding
    int offset(dwBufLen-1);
    if ((offset >= 0) && (pBuffer[offset] == '='))
      --m_nDecodedLength;
    if (((offset-1) >= 0) && (pBuffer[offset-1] == '='))
      --m_nDecodedLength;
  }
//}}}
//{{{
void Base64Coder::Decode (const char* szMessage) {
  if(szMessage != NULL)
    Base64Coder::Decode((const PBYTE)szMessage, strlen(szMessage));
  }
//}}}

//private
//{{{
DWORD Base64Coder::_DecodeToBuffer (const TempBucket &Decode, PBYTE pBuffer) {
  TempBucket  Data;
  DWORD     nCount = 0;

  _DecodeRaw(Data, Decode);

  for(int i = 0; i < 3; ++i) {
    pBuffer[i] = Data.nData[i];
    if(pBuffer[i] != 255)
      ++nCount;
    }

  return nCount;
  }
//}}}
//{{{
void Base64Coder::_EncodeToBuffer (const TempBucket &Decode, PBYTE pBuffer) {
  TempBucket  Data;

  _EncodeRaw(Data, Decode);

  if (m_useAlternateMapping) {
    for (int i = 0; i < 4; ++i)
      pBuffer[i] = AlternateBase64Digits[Data.nData[i]];
    }
  else {
    for (int i = 0; i < 4; ++i)
    pBuffer[i] = Base64Digits[Data.nData[i]];
    }

  switch (Decode.nSize) {
    case 1:
      pBuffer[2] = '=';
    case 2:
      pBuffer[3] = '=';
    }
  }
//}}}

//{{{
void Base64Coder::_DecodeRaw (TempBucket &Data, const TempBucket &Decode) {
  BYTE    nTemp;

  Data.nData[0] = Decode.nData[0];
  Data.nData[0] <<= 2;

  nTemp = Decode.nData[1];
  nTemp >>= 4;
  nTemp &= 0x03;
  Data.nData[0] |= nTemp;

  Data.nData[1] = Decode.nData[1];
  Data.nData[1] <<= 4;

  nTemp = Decode.nData[2];
  nTemp >>= 2;
  nTemp &= 0x0F;
  Data.nData[1] |= nTemp;

  Data.nData[2] = Decode.nData[2];
  Data.nData[2] <<= 6;
  nTemp = Decode.nData[3];
  nTemp &= 0x3F;
  Data.nData[2] |= nTemp;
  }
//}}}
//{{{
void Base64Coder::_EncodeRaw (TempBucket &Data, const TempBucket &Decode) {
  BYTE    nTemp;

  Data.nData[0] = Decode.nData[0];
  Data.nData[0] >>= 2;

  Data.nData[1] = Decode.nData[0];
  Data.nData[1] <<= 4;
  nTemp = Decode.nData[1];
  nTemp >>= 4;
  Data.nData[1] |= nTemp;
  Data.nData[1] &= 0x3F;

  Data.nData[2] = Decode.nData[1];
  Data.nData[2] <<= 2;

  nTemp = Decode.nData[2];
  nTemp >>= 6;

  Data.nData[2] |= nTemp;
  Data.nData[2] &= 0x3F;

  Data.nData[3] = Decode.nData[2];
  Data.nData[3] &= 0x3F;
  }
//}}}

//{{{
BOOL Base64Coder::_IsBadMimeChar (BYTE nData) {
  switch(nData) {
    case '\r': case '\n': case '\t': case ' ' :
    case '\b': case '\a': case '\f': case '\v':
      return TRUE;
    default:
      return FALSE;
    }
  }
//}}}

//{{{
void Base64Coder::_Init() {
  // Initialize Decoding table.
  int i;

  for (i = 0; i < 256; ++i)
    Base64Coder::m_DecodeTable[i] = -2;

  if (m_useAlternateMapping) {
    for (i = 0; i < 64; ++i) {
      Base64Coder::m_DecodeTable[AlternateBase64Digits[i]]      = i;
      Base64Coder::m_DecodeTable[AlternateBase64Digits[i]|0x80] = i;
      }
    }
  else {
    for (i = 0; i < 64; ++i) {
      Base64Coder::m_DecodeTable[Base64Digits[i]]      = i;
      Base64Coder::m_DecodeTable[Base64Digits[i]|0x80] = i;
      }
    }

  Base64Coder::m_DecodeTable['=']      = -1;
  Base64Coder::m_DecodeTable['='|0x80] = -1;

  Base64Coder::m_Init = TRUE;
  AlternateDigits = m_useAlternateMapping;
  }
//}}}

